package com.frameworkset.proxy;

import java.lang.reflect.Method;
import java.lang.reflect.UndeclaredThrowableException;
import java.util.ArrayList;
import java.util.List;

/**
 * <p>Title: </p>
 *
 * <p>Description: </p>
 *
 * <p>Copyright: Copyright (c) 2005</p>
 *
 * <p>Company: </p>
 *
 * @author biaoping.yin
 * @version 1.0
 */
public class TestInvocationHandler extends InvocationHandler {
    /**
     * Processes a method invocation on a proxy instance and returns the
     * result.
     *
     * @param proxy the proxy instance that the method was invoked on
     * @param method the <code>Method</code> instance corresponding to the
     *   interface method invoked on the proxy instance. The declaring class
     *   of the <code>Method</code> object will be the interface that the
     *   method was declared in, which may be a superinterface of the proxy
     *   interface that the proxy class inherits the method through.
     * @param args an array of objects containing the values of the
     *   arguments passed in the method invocation on the proxy instance, or
     *   <code>null</code> if interface method takes no arguments. Arguments
     *   of primitive types are wrapped in instances of the appropriate
     *   primitive wrapper class, such as <code>java.lang.Integer</code> or
     *   <code>java.lang.Boolean</code>.
     * @return the value to return from the method invocation on the proxy
     *   instance. If the declared return type of the interface method is a
     *   primitive type, then the value returned by this method must be an
     *   instance of the corresponding primitive wrapper class; otherwise,
     *   it must be a type assignable to the declared return type. If the
     *   value returned by this method is <code>null</code> and the
     *   interface method's return type is primitive, then a
     *   <code>NullPointerException</code> will be thrown by the method
     *   invocation on the proxy instance. If the value returned by this
     *   method is otherwise not compatible with the interface method's
     *   declared return type as described above, a
     *   <code>ClassCastException</code> will be thrown by the method
     *   invocation on the proxy instance.
     * @throws Throwable the exception to throw from the method invocation
     *   on the proxy instance. The exception's type must be assignable
     *   either to any of the exception types declared in the
     *   <code>throws</code> clause of the interface method or to the
     *   unchecked exception types <code>java.lang.RuntimeException</code>
     *   or <code>java.lang.Error</code>. If a checked exception is thrown
     *   by this method that is not assignable to any of the exception types
     *   declared in the <code>throws</code> clause of the interface method,
     *   then an {@link UndeclaredThrowableException} containing the
     *   exception that was thrown by this method will be thrown by the
     *   method invocation on the proxy instance.
     * @todo Implement this java.lang.reflect.InvocationHandler method
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws
        Throwable {
        List list = new ArrayList();
        for(int i = 0; i < 5; i ++)
        {
            TestProxyImpl t = new TestProxyImpl();
            t.setString("hello" + i);
            list.add(t);
        }
        Object obj = method.invoke(super.delegate,args);
        for(int i = 0; i < 5; i ++)
        {
            System.out.println(obj);
            obj = method.invoke(list.get(i), args);
        }
        return obj;
    }
    public TestInvocationHandler(Object delegate)
    {
        super(delegate);
    }
    public static void main(String[] args) {
    }
}
